package qc.module.ehs.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import qc.common.core.exception.QCPromptException;
import qc.common.core.unify.QCUnifyReturnValue;
import qc.common.core.utils.IdentifierUtil;
import qc.module.ehs.dto.unit.*;
import qc.module.ehs.entity.EhsOrg;
import qc.module.ehs.entity.EhsTplUnitcategory;
import qc.module.ehs.entity.EhsUnitBasic;
import qc.module.ehs.mapper.EhsUnitBasicMapper;
import qc.module.ehs.repository.EhsOrgRepository;
import qc.module.ehs.repository.EhsTplUnitcategoryRepository;
import qc.module.ehs.repository.EhsUnitBasicRepository;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 * 单元划分基础信息接口Service
 *
 * @author QuCheng Tech
 * @create 2024/5/22
 */
@Service
public class EhsUnitBasicService {
    
    private EhsUnitBasicRepository repository;

    @Autowired
    public void setRepository(EhsUnitBasicRepository repository) {
        this.repository = repository;
    }
    
    @Autowired
    private EhsOrgRepository orgRepository;
    
    @Autowired
    private EhsTplUnitcategoryRepository unitcategoryRepository;

    /**
     * 查询单元信息，以TreeTable树型形式返回数据
     * 根据组织代码查询结果，从结果中筛选符合查询条件的结果
     *
     * @param condition 查询条件
     * @param deptIds 当前用户关联的部门ID集合
     * @return List<EhsUnitTreeTableItemDto>
     * @author QuCheng Tech
     * @since 2024/5/30
     */
    public List<EhsUnitTreeTableItemDto> queryTreeTable(EhsUnitQueryConditionDto condition,List<Integer> deptIds) throws QCPromptException {
        //1.查询条件判断
        if (condition == null) throw new QCPromptException("查询条件不能为空");
        if (StringUtils.isBlank(condition.getOrgcode())) throw new QCPromptException("组织代码不能为空");
        if (condition.getIncludechilds() == null) throw new QCPromptException("是否包含子级不能为空");
        if (condition.getIsdept() == null) throw new QCPromptException("是否根据用户部门进行过滤不能为空");
        
        //2.根据组织代码查询单元
        LambdaQueryWrapper<EhsUnitBasic> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(EhsUnitBasic::getOrgcode,condition.getOrgcode());
        wrapper.orderByAsc(EhsUnitBasic::getOdr,EhsUnitBasic::getUnitname);
        List<EhsUnitBasic> ens = repository.selectList(wrapper);
        if (CollectionUtils.isEmpty(ens)) return null;

        //3.ens转换为TreeTableItemDto
        List<EhsUnitTreeTableItemDto> dtos = EhsUnitBasicMapper.MAPPER.toTreeTableItemDtoList(ens);
        
        //4.将查询结果构建为树型结构
        List<EhsUnitTreeTableItemDto> result = new ArrayList<>();
        List<EhsUnitTreeTableItemDto> rootUnits = dtos.stream().filter(p -> StringUtils.isEmpty(p.getParentid())).collect(Collectors.toList());
        if (CollectionUtils.isNotEmpty(rootUnits)){
            result = getSubUnits(dtos,rootUnits);
        }
        
        //5.从result中筛选符合查询条件的结果
        Iterator<EhsUnitTreeTableItemDto> rootLevelIterator = result.iterator();
        while (rootLevelIterator.hasNext()){
            EhsUnitTreeTableItemDto rootlevel = rootLevelIterator.next();
            
            if (rootlevel.getChildren() != null && rootlevel.getChildren().size() > 0x0){
                //子级结果筛选
                filterSubTreeTableResult(rootlevel,condition,deptIds);
            }
            
            //是否移除
            boolean isRemoveRootLevel = false;
            //上级单元编码不为空的情况，匹配了再判断是否包含子级
            if (StringUtils.isNotBlank(condition.getParentid())){
                if (rootlevel.getParentid().equals(condition.getParentid())){
                    //匹配，判断是否包含子级，不包含则设置子级为空
                    if (!condition.getIncludechilds()) rootlevel.setChildren(null);
                }else{
                    //第一次层级不匹配，移除
                    isRemoveRootLevel = true;
                }
            }else{
                //如果上级单元编码为空，判断是否包含子级
                if (!condition.getIncludechilds()) rootlevel.setChildren(null);
            }
            
            if (rootlevel.getChildren() == null || rootlevel.getChildren().size() == 0x0){
                //单元分类代码
                //if (StringUtils.isNotBlank(condition.getCategorycode())){
                //    if (!rootlevel.getCategorycode().equals(condition.getCategorycode()))
                //        isRemoveRootLevel = true;
                //}
                //单元类型
                if (StringUtils.isNotBlank(condition.getUnittype())){
                    if (rootlevel.getUnittype() != Integer.parseInt(condition.getUnittype()))
                        isRemoveRootLevel = true;
                }
                //是否为独立场所/区域：为0表示false，为1表示true，为空或其他时表示不管该标记状态
                //if (StringUtils.isNotBlank(condition.getIsindependent())){
                //    if (condition.getIsindependent().equals("0")){
                //        //false，筛选单元类型为子单元的
                //        if (rootlevel.getUnittype() != EhsUnitTypeEnum.SUB.getIndex()) isRemoveRootLevel = true;
                //    }else if (condition.getIsindependent().equals("1")){
                //        //true，筛选单元类型为主单元的
                //        if (rootlevel.getUnittype() != EhsUnitTypeEnum.MAJOR.getIndex()) isRemoveRootLevel = true;
                //    }
                //}
                //是否为在建工程：为0表示false，为1表示true，为空或其他时表示不管该标记状态
                if (StringUtils.isNotBlank(condition.getIsconstruction())){
                    if (condition.getIsconstruction().equals("0")){
                        if (rootlevel.getIsconstruction() == true) isRemoveRootLevel = true;
                    }else if (condition.getIsconstruction().equals("1")){
                        if (rootlevel.getIsconstruction() == false) isRemoveRootLevel = true;
                    }
                }
                //是否根据用户部门进行过滤:为true表示根据当前用户所关联部门对单元进行筛选过滤，为false表示不过滤
                if (condition.getIsdept()){
                    if (CollectionUtils.isNotEmpty(deptIds)){
                        boolean deptIsExist = false;//level4的部门是否匹配用户部门
                        for (Integer deptId : deptIds){
                            if (deptId == rootlevel.getDeptid()){
                                deptIsExist = true;
                            }
                        }
                        if (!deptIsExist) isRemoveRootLevel = true;
                    }
                }
                //关键子匹配
                if (StringUtils.isNotBlank(condition.getKeywords())){
                    if (!(rootlevel.getUnitid().contains(condition.getKeywords())) && 
                            !(rootlevel.getUnitname().contains(condition.getKeywords()))
                    ){
                        isRemoveRootLevel = true;
                    }
                }
                if (isRemoveRootLevel) rootLevelIterator.remove();
            }
            
        }
        
        //6.返回结果
        return result;
    }
    
    /**
     * 递归获取子级单元信息
     *
     * @param dtos 所有单元信息
     * @param parentUnits 父级单元信息
     * @return List<EhsUnitTreeTableItemDto>
     * @author QuCheng Tech
     * @since 2024/5/23
     */
    private List<EhsUnitTreeTableItemDto> getSubUnits(List<EhsUnitTreeTableItemDto> dtos,List<EhsUnitTreeTableItemDto> parentUnits){
        List<EhsUnitTreeTableItemDto> result = new ArrayList<>();

        if (CollectionUtils.isEmpty(dtos)) return null;

        if (CollectionUtils.isNotEmpty(parentUnits)){
            for (EhsUnitTreeTableItemDto pUnit : parentUnits){
                //获取子级单元信息集合
                List<EhsUnitTreeTableItemDto> subUnits = dtos.stream().filter(p -> pUnit.getUnitid().equals(p.getParentid())).collect(Collectors.toList());
                if (CollectionUtils.isNotEmpty(subUnits)){
                    getSubUnits(dtos,subUnits);
                    pUnit.setChildren(subUnits);
                }
                result.add(pUnit);
            }
        }
        return result;
    }
    

    /**
     * 递归过滤单元TreeTable的子级结果
     * 
     * @param rootLevel 父层级单元
     * @param condition 过滤条件
     * @param deptIds 当前用户所属部门集合
     * @author QuCheng Tech
     * @since 2024/5/30
     */
    private void filterSubTreeTableResult(EhsUnitTreeTableItemDto rootLevel,EhsUnitQueryConditionDto condition,List<Integer> deptIds){
        Iterator<EhsUnitTreeTableItemDto> subLevelIterator = rootLevel.getChildren().iterator();
        while (subLevelIterator.hasNext()){
            EhsUnitTreeTableItemDto subLevel = subLevelIterator.next();

            if (subLevel.getChildren() != null && subLevel.getChildren().size() > 0x0){
                filterSubTreeTableResult(subLevel,condition,deptIds);
            }
            
            //上级单元编码不为空的情况，匹配了再判断是否包含子级
            if (StringUtils.isNotBlank(condition.getParentid())){
                if (subLevel.getParentid().equals(condition.getParentid())){
                    //匹配，判断是否包含子级，不包含则设置子级为空
                    if (!condition.getIncludechilds()) subLevel.setChildren(null);
                }
            }else{
                //如果上级单元编码为空，判断是否包含子级
                if (!condition.getIncludechilds()) subLevel.setChildren(null);
            }
            
            if (subLevel.getChildren() == null || subLevel.getChildren().size() == 0x0){
                //是否移除
                boolean isRemoveSubLevel = false;
                //单元分类代码
                //if (StringUtils.isNotBlank(condition.getCategorycode())){
                //    if (!subLevel.getCategorycode().equals(condition.getCategorycode()))
                //        isRemoveSubLevel = true;
                //}
                //单元类型
                if (StringUtils.isNotBlank(condition.getUnittype())){
                    if (subLevel.getUnittype() != Integer.parseInt(condition.getUnittype()))
                        isRemoveSubLevel = true;
                }
                //是否为独立场所/区域：为0表示false，为1表示true，为空或其他时表示不管该标记状态
                //if (StringUtils.isNotBlank(condition.getIsindependent())){
                //    if (condition.getIsindependent().equals("0")){
                //        //false，筛选单元类型为子单元的
                //        if (subLevel.getUnittype() != EhsUnitTypeEnum.SUB.getIndex()) isRemoveSubLevel = true;
                //    }else if (condition.getIsindependent().equals("1")){
                //        //true，筛选单元类型为主单元的
                //        if (subLevel.getUnittype() != EhsUnitTypeEnum.MAJOR.getIndex()) isRemoveSubLevel = true;
                //    }
                //}
                //是否为在建工程：为0表示false，为1表示true，为空或其他时表示不管该标记状态
                if (StringUtils.isNotBlank(condition.getIsconstruction())){
                    if (condition.getIsconstruction().equals("0")){
                        if (subLevel.getIsconstruction() == true) isRemoveSubLevel = true;
                    }else if (condition.getIsconstruction().equals("1")){
                        if (subLevel.getIsconstruction() == false) isRemoveSubLevel = true;
                    }
                }
                //是否根据用户部门进行过滤:为true表示根据当前用户所关联部门对单元进行筛选过滤，为false表示不过滤
                if (condition.getIsdept()){
                    if (CollectionUtils.isNotEmpty(deptIds)){
                        boolean deptIsExist = false;//level4的部门是否匹配用户部门
                        for (Integer deptId : deptIds){
                            if (deptId == subLevel.getDeptid()){
                                deptIsExist = true;
                            }
                        }
                        if (!deptIsExist) isRemoveSubLevel = true;
                    }
                }
                //关键子匹配
                if (StringUtils.isNotBlank(condition.getKeywords())){
                    if (!(subLevel.getUnitid().contains(condition.getKeywords())) &&
                            !(subLevel.getUnitname().contains(condition.getKeywords()))
                    ){
                        isRemoveSubLevel = true;
                    }
                }
                if (isRemoveSubLevel) subLevelIterator.remove();
            }

        }
    }
    
    /**
     * 查询单元简要信息
     * 用于在其他模块（如危险源台账）作为查询条件或表单选择数据接口使用；以层级形式返回单元列表（可以根据条件根据用户部门筛选）
     *
     * @param condition 查询条件
     * @return List<EhsUnitTreeSimpleDto>
     * @throws QCPromptException
     * @author QuCheng Tech
     * @since 2024/5/31
     */
    public List<EhsUnitTreeSimpleDto> queryTreeSimple(EhsUnitQueryConditionDto condition,List<Integer> deptIds) throws QCPromptException {
        //1.查询条件判断
        if (condition == null) throw new QCPromptException("查询条件不能为空");
        if (StringUtils.isBlank(condition.getOrgcode())) throw new QCPromptException("组织代码不能为空");
        if (condition.getIncludechilds() == null) throw new QCPromptException("是否包含子级不能为空");
        if (condition.getIsdept() == null) throw new QCPromptException("是否根据用户部门进行过滤不能为空");

        //2.根据组织代码查询单元
        LambdaQueryWrapper<EhsUnitBasic> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(EhsUnitBasic::getOrgcode,condition.getOrgcode());
        wrapper.orderByAsc(EhsUnitBasic::getOdr,EhsUnitBasic::getUnitname);
        List<EhsUnitBasic> ens = repository.selectList(wrapper);
        if (CollectionUtils.isEmpty(ens)) return null;
        
        //3.转换为dtoSimpleList
        List<EhsUnitSimpleDto> dtos = EhsUnitBasicMapper.MAPPER.toDtoSimpleList(ens);

        List<EhsUnitTreeSimpleDto> result = new ArrayList<>();
        
        //4.将查询结果构建为树型结构
        List<EhsUnitSimpleDto> rootUnits = dtos.stream().filter(p -> StringUtils.isEmpty(p.getParentid())).collect(Collectors.toList());
        if (CollectionUtils.isNotEmpty(rootUnits)){
            for (EhsUnitSimpleDto rootUnit : rootUnits){
                EhsUnitTreeSimpleDto unitTreeSimpleDto = new EhsUnitTreeSimpleDto();
                List<EhsUnitTreeSimpleDto> children = new ArrayList<>();
                unitTreeSimpleDto.setInfo(rootUnit);
                unitTreeSimpleDto.setChildren(children);
                getSubUnitsSimple(dtos,rootUnit,children);
                result.add(unitTreeSimpleDto);
            }
        }

        //5.从result中筛选符合查询条件的结果
        Iterator<EhsUnitTreeSimpleDto> rootLevelIterator = result.iterator();
        while (rootLevelIterator.hasNext()){
            EhsUnitTreeSimpleDto rootlevel = rootLevelIterator.next();

            if (rootlevel.getChildren() != null && rootlevel.getChildren().size() > 0x0){
                //子级结果筛选
                filterSubTreeSimpleResult(rootlevel,condition,deptIds);
            }

            //是否移除
            boolean isRemoveRootLevel = false;
            //上级单元编码不为空的情况，匹配了再判断是否包含子级
            if (StringUtils.isNotBlank(condition.getParentid())){
                if (rootlevel.getInfo().getParentid().equals(condition.getParentid())){
                    //匹配，判断是否包含子级，不包含则设置子级为空
                    if (!condition.getIncludechilds()) rootlevel.setChildren(null);
                }else{
                    //第一次层级不匹配，移除
                    isRemoveRootLevel = true;
                }
            }else{
                //如果上级单元编码为空，判断是否包含子级
                if (!condition.getIncludechilds()) rootlevel.setChildren(null);
            }

            if (rootlevel.getChildren() == null || rootlevel.getChildren().size() == 0x0){
                //单元分类代码
                //if (StringUtils.isNotBlank(condition.getCategorycode())){
                //    if (!rootlevel.getInfo().getCategorycode().equals(condition.getCategorycode()))
                //        isRemoveRootLevel = true;
                //}
                //单元类型
                if (StringUtils.isNotBlank(condition.getUnittype())){
                    if (rootlevel.getInfo().getUnittype() != Integer.parseInt(condition.getUnittype()))
                        isRemoveRootLevel = true;
                }
                //是否为独立场所/区域：为0表示false，为1表示true，为空或其他时表示不管该标记状态
                //if (StringUtils.isNotBlank(condition.getIsindependent())){
                //    if (condition.getIsindependent().equals("0")){
                //        //false，筛选单元类型为子单元的
                //        if (rootlevel.getInfo().getUnittype() != EhsUnitTypeEnum.SUB.getIndex()) isRemoveRootLevel = true;
                //    }else if (condition.getIsindependent().equals("1")){
                //        //true，筛选单元类型为主单元的
                //        if (rootlevel.getInfo().getUnittype() != EhsUnitTypeEnum.MAJOR.getIndex()) isRemoveRootLevel = true;
                //    }
                //}
                //是否为在建工程：为0表示false，为1表示true，为空或其他时表示不管该标记状态
                if (StringUtils.isNotBlank(condition.getIsconstruction())){
                    if (condition.getIsconstruction().equals("0")){
                        if (rootlevel.getInfo().getIsconstruction() == true) isRemoveRootLevel = true;
                    }else if (condition.getIsconstruction().equals("1")){
                        if (rootlevel.getInfo().getIsconstruction() == false) isRemoveRootLevel = true;
                    }
                }
                //是否根据用户部门进行过滤:为true表示根据当前用户所关联部门对单元进行筛选过滤，为false表示不过滤
                if (condition.getIsdept()){
                    if (CollectionUtils.isNotEmpty(deptIds)){
                        boolean deptIsExist = false;//level4的部门是否匹配用户部门
                        for (Integer deptId : deptIds){
                            if (deptId == rootlevel.getInfo().getDeptid()){
                                deptIsExist = true;
                            }
                        }
                        if (!deptIsExist) isRemoveRootLevel = true;
                    }
                }
                //关键子匹配
                if (StringUtils.isNotBlank(condition.getKeywords())){
                    if (!(rootlevel.getInfo().getUnitid().contains(condition.getKeywords())) &&
                            !(rootlevel.getInfo().getUnitname().contains(condition.getKeywords()))
                    ){
                        isRemoveRootLevel = true;
                    }
                }
                if (isRemoveRootLevel) rootLevelIterator.remove();
            }

        }
        
        return result;
    }

    /**
     * 拼接父级单元的子孙层级结构
     *
     * @param dtos 所有单元信息
     * @param parentUnit 父级单元
     * @param parentChilds  父级单元的子孙集合
     * @author QuCheng Tech
     * @since 2024/5/31
     */
    public void getSubUnitsSimple(List<EhsUnitSimpleDto> dtos, EhsUnitSimpleDto parentUnit, List<EhsUnitTreeSimpleDto> parentChilds) {
        List<EhsUnitSimpleDto> subUnits = dtos.stream().filter(p -> p.getParentid() != null && 
                p.getParentid().equals(parentUnit.getUnitid())).collect(Collectors.toList());
        for (EhsUnitSimpleDto subUnit : subUnits) {
            EhsUnitTreeSimpleDto unitTreeSimpleDto = new EhsUnitTreeSimpleDto();
            List<EhsUnitTreeSimpleDto> children = new ArrayList<>();
            unitTreeSimpleDto.setInfo(subUnit);
            unitTreeSimpleDto.setChildren(children);

            parentChilds.add(unitTreeSimpleDto);

            getSubUnitsSimple(dtos, subUnit, children);
        }
    }

    /**
     * 递归过滤单元TreeSimple的子级结果
     *
     * @param rootLevel 父层级单元
     * @param condition 过滤条件
     * @param deptIds 当前用户所属部门集合
     * @author QuCheng Tech
     * @since 2024/5/31
     */
    private void filterSubTreeSimpleResult(EhsUnitTreeSimpleDto rootLevel,EhsUnitQueryConditionDto condition,List<Integer> deptIds){
        Iterator<EhsUnitTreeSimpleDto> subLevelIterator = rootLevel.getChildren().iterator();
        while (subLevelIterator.hasNext()){
            EhsUnitTreeSimpleDto subLevel = subLevelIterator.next();

            if (subLevel.getChildren() != null && subLevel.getChildren().size() > 0x0){
                filterSubTreeSimpleResult(subLevel,condition,deptIds);
            }

            //上级单元编码不为空的情况，匹配了再判断是否包含子级
            if (StringUtils.isNotBlank(condition.getParentid())){
                if (subLevel.getInfo().getParentid().equals(condition.getParentid())){
                    //匹配，判断是否包含子级，不包含则设置子级为空
                    if (!condition.getIncludechilds()) subLevel.setChildren(null);
                }
            }else{
                //如果上级单元编码为空，判断是否包含子级
                if (!condition.getIncludechilds()) subLevel.setChildren(null);
            }

            if (subLevel.getChildren() == null || subLevel.getChildren().size() == 0x0){
                //是否移除
                boolean isRemoveSubLevel = false;
                //单元分类代码
                //if (StringUtils.isNotBlank(condition.getCategorycode())){
                //    if (!subLevel.getInfo().getCategorycode().equals(condition.getCategorycode()))
                //        isRemoveSubLevel = true;
                //}
                //单元类型
                if (StringUtils.isNotBlank(condition.getUnittype())){
                    if (subLevel.getInfo().getUnittype() != Integer.parseInt(condition.getUnittype()))
                        isRemoveSubLevel = true;
                }
                //是否为独立场所/区域：为0表示false，为1表示true，为空或其他时表示不管该标记状态
                //if (StringUtils.isNotBlank(condition.getIsindependent())){
                //    if (condition.getIsindependent().equals("0")){
                //        //false，筛选单元类型为子单元的
                //        if (subLevel.getInfo().getUnittype() != EhsUnitTypeEnum.SUB.getIndex()) isRemoveSubLevel = true;
                //    }else if (condition.getIsindependent().equals("1")){
                //        //true，筛选单元类型为主单元的
                //        if (subLevel.getInfo().getUnittype() != EhsUnitTypeEnum.MAJOR.getIndex()) isRemoveSubLevel = true;
                //    }
                //}
                //是否为在建工程：为0表示false，为1表示true，为空或其他时表示不管该标记状态
                if (StringUtils.isNotBlank(condition.getIsconstruction())){
                    if (condition.getIsconstruction().equals("0")){
                        if (subLevel.getInfo().getIsconstruction() == true) isRemoveSubLevel = true;
                    }else if (condition.getIsconstruction().equals("1")){
                        if (subLevel.getInfo().getIsconstruction() == false) isRemoveSubLevel = true;
                    }
                }
                //是否根据用户部门进行过滤:为true表示根据当前用户所关联部门对单元进行筛选过滤，为false表示不过滤
                if (condition.getIsdept()){
                    if (CollectionUtils.isNotEmpty(deptIds)){
                        boolean deptIsExist = false;//level4的部门是否匹配用户部门
                        for (Integer deptId : deptIds){
                            if (deptId == subLevel.getInfo().getDeptid()){
                                deptIsExist = true;
                            }
                        }
                        if (!deptIsExist) isRemoveSubLevel = true;
                    }
                }
                //关键子匹配
                if (StringUtils.isNotBlank(condition.getKeywords())){
                    if (!(subLevel.getInfo().getUnitid().contains(condition.getKeywords())) &&
                            !(subLevel.getInfo().getUnitname().contains(condition.getKeywords()))
                    ){
                        isRemoveSubLevel = true;
                    }
                }
                if (isRemoveSubLevel) subLevelIterator.remove();
            }

        }
    }

    /**
     * 查询单元信息，以List形式返回数据
     *
     * @param condition 查询条件
     * @param deptIds 当前用户关联的部门ID集合
     * @return List<EhsUnitTreeTableItemDto>
     * @author QuCheng Tech
     * @since 2024/5/23
     */
    public List<EhsUnitDto> queryList(EhsUnitQueryConditionDto condition,List<Integer> deptIds) throws QCPromptException {
        //1.条件判空
        if (condition == null) throw new QCPromptException("条件不能为空");
        if (StringUtils.isBlank(condition.getOrgcode())) throw new QCPromptException("组织代码不能为空");
        if (condition.getIncludechilds() == null) throw new QCPromptException("是否包含子级不能为空");
        if (condition.getIsdept() == null) throw new QCPromptException("是否根据用户部门进行过滤不能为空");

        //2.构造查询条件
        LambdaQueryWrapper<EhsUnitBasic> wrapper = new LambdaQueryWrapper<>();
        //组织代码
        wrapper.eq(EhsUnitBasic::getOrgcode,condition.getOrgcode());
        
        //3.查询数据
        List<EhsUnitBasic> ens = repository.selectList(wrapper);
        if (CollectionUtils.isEmpty(ens)) return null;
        
        //4.转化为dtos
        List<EhsUnitDto> dtos = EhsUnitBasicMapper.MAPPER.toDtoList(ens);
        
        //5.从dtos中筛选符合查询条件的数据
        
        return null;
    }

    /**
     * 获取指定 - 同时支持@RequestParam和@PathVariable方式
     *
     * @param id 单元代码
     * @return EhsUnitDto
     * @author QuCheng Tech
     * @since 2024/5/22
     */
    public EhsUnitDto get(String id) throws QCPromptException {
        if (StringUtils.isBlank(id)) throw new QCPromptException("单元代码不能为空");
        
        EhsUnitBasic en = repository.selectById(id);
        if (Objects.nonNull(en)){
            return EhsUnitBasicMapper.MAPPER.toDto(en);
        }
        return null;
    }

    /**
     * 新增 
     *
     * @param dto 单元信息
     * @return 成功返回null，失败返回错误或提示信息
     * @author QuCheng Tech
     * @since 2024/5/22
     */
    public String add(EhsUnitDto dto){
        //1.单元信息判空
        if (dto == null) return QCUnifyReturnValue.Warn("单元信息不能为空");
        //if (StringUtils.isBlank(dto.getUnitcode())) return QCUnifyReturnValue.Warn("单元编码不能为空");
        if (StringUtils.isBlank(dto.getUnitname())) return QCUnifyReturnValue.Warn("单元名称不能为空");
        //if (StringUtils.isBlank(dto.getOrgcode())) return QCUnifyReturnValue.Warn("组织编码不能为空");
        //if (dto.getDeptid() == null || dto.getDeptid() < 0x1) return QCUnifyReturnValue.Warn("所属部门ID不能为空");
        //if (StringUtils.isBlank(dto.getCategorycode())) return QCUnifyReturnValue.Warn("所属单元分类不能为空");
        //if (dto.getUnittype() == null || dto.getUnittype() < 0x1) return QCUnifyReturnValue.Warn("单元类型不能为空");
        //if (dto.getIsconstruction() == null) return QCUnifyReturnValue.Warn("是否为在建阶段不能为空");
        
        //2.判断单元ID是否存在，存在则提示
        if (isExist(dto.getUnitid())) return QCUnifyReturnValue.Warn("单元ID已经存在");
        
        //3.判断组织编码是否存在，不存在则提示
        if (StringUtils.isNotBlank(dto.getOrgcode())){
            EhsOrg ehsOrg = orgRepository.selectById(dto.getOrgcode());
            if (Objects.isNull(ehsOrg)) return QCUnifyReturnValue.Warn("组织编码不存在");
        }
        
        //4.判断所属单元分类是否存在，不存在则提示
        //if (StringUtils.isNotBlank(dto.getCategorycode())){
        //    EhsTplUnitcategory unitcategory = unitcategoryRepository.selectById(dto.getCategorycode());
        //    if (Objects.isNull(unitcategory)) return QCUnifyReturnValue.Warn("所属单元分类不存在");
        //}
        
        //5.如果有上级单元编码，判断上级单元编码是否存在，不存在则提示
        if (StringUtils.isNotBlank(dto.getParentid())) {
            if (!isExist(dto.getParentid())) return QCUnifyReturnValue.Warn("上级单元ID不存在");
        }
        
        //6.dto -> entity
        EhsUnitBasic en = EhsUnitBasicMapper.MAPPER.dtoToEntity(dto);
        
        //7.设置单元ID
        en.setUnitid(IdentifierUtil.randomUUID());
        
        //8.保存数据
        if (repository.insert(en) < 0x1) 
            return QCUnifyReturnValue.Warn("保存失败");
        return QCUnifyReturnValue.Success();
    }

    /**
     * 修改
     *
     * @param dto 单元信息
     * @return 成功返回null，失败返回错误或提示信息
     * @author QuCheng Tech
     * @since 2024/5/23
     */
    public String update(EhsUnitDto dto){
        //1.单元信息判空
        if (dto == null) return QCUnifyReturnValue.Warn("单元信息不能为空");
        if (StringUtils.isBlank(dto.getUnitid())) return QCUnifyReturnValue.Warn("单元ID不能为空");
        if (StringUtils.isBlank(dto.getUnitname())) return QCUnifyReturnValue.Warn("单元名称不能为空");
        //if (StringUtils.isBlank(dto.getOrgcode())) return QCUnifyReturnValue.Warn("组织编码不能为空");
        //if (dto.getDeptid() == null || dto.getDeptid() < 0x1) return QCUnifyReturnValue.Warn("所属部门ID不能为空");
        //if (StringUtils.isBlank(dto.getCategorycode())) return QCUnifyReturnValue.Warn("所属单元分类不能为空");
        //if (dto.getUnittype() == null || dto.getUnittype() < 0x1) return QCUnifyReturnValue.Warn("单元类型不能为空");
        //if (dto.getIsconstruction() == null) return QCUnifyReturnValue.Warn("是否为在建阶段不能为空");
        
        //2.判断单元编码是否存在，不存在则提示
        if (!isExist(dto.getUnitid())) return QCUnifyReturnValue.Warn("单元ID不存在");

        //3.判断组织编码是否存在，不存在则提示
        if (StringUtils.isNotBlank(dto.getOrgcode())){
            EhsOrg ehsOrg = orgRepository.selectById(dto.getOrgcode());
            if (Objects.isNull(ehsOrg)) return QCUnifyReturnValue.Warn("组织编码不存在");
        }

        //4.判断所属单元分类是否存在，不存在则提示
        //EhsTplUnitcategory unitcategory = unitcategoryRepository.selectById(dto.getCategorycode());
        //if (Objects.isNull(unitcategory)) return QCUnifyReturnValue.Warn("所属单元分类不存在");

        //5.如果有上级单元编码，判断上级单元编码是否存在，不存在则提示
        if (StringUtils.isNotBlank(dto.getParentid())) {
            if (!isExist(dto.getParentid())) return QCUnifyReturnValue.Warn("上级单元ID不存在");
        }
        
        //6.dto -> entity
        EhsUnitBasic en = EhsUnitBasicMapper.MAPPER.dtoToEntity(dto);
        
        //7.更新数据
        repository.updateById(en);
        return QCUnifyReturnValue.Success();
    }

    /**
     * 删除 - 同时支持@RequestParam和@PathVariable方式
     *
     * @param id 单元编码
     * @return 成功返回null，失败返回错误或提示信息
     * @author QuCheng Tech
     * @since 2024/5/23
     */
    public String delete(String id){
        if (StringUtils.isBlank(id)) return QCUnifyReturnValue.Warn("单元ID不能为空");

        //判断单元下是否有子级单元，有则不允许删除
        LambdaQueryWrapper<EhsUnitBasic> wrapper = new LambdaQueryWrapper<>();
        wrapper.select(EhsUnitBasic::getUnitid);
        wrapper.eq(EhsUnitBasic::getParentid,id);
        List<EhsUnitBasic> ens = repository.selectList(wrapper);
        if (CollectionUtils.isNotEmpty(ens)) return QCUnifyReturnValue.Warn("该单元下有子级单元，请先删除子级单元信息");
        
        repository.deleteById(id);
        return QCUnifyReturnValue.Success();
    }

    /**
     * 判断单元代码是否存在
     *
     * @param id 单元代码
     * @return 存在返回true，否则返回false
     * @author QuCheng Tech
     * @since 2024/5/23
     */
    private boolean isExist(String id){
        EhsUnitBasic en = repository.selectById(id);
        if (Objects.nonNull(en)){
            return true;
        }
        return false;
    }

    /**
     * 根据指定组织代码查询单元信息
     * 
     * @param orgCode 组织代码
     * @return List<EhsUnitDto>
     * @author QuCheng Tech
     * @since 2024/5/22
     */
    public List<EhsUnitDto> getUnitByOrgCode(String orgCode){
        LambdaQueryWrapper<EhsUnitBasic> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(EhsUnitBasic::getOrgcode,orgCode);
        
        List<EhsUnitBasic> ens = repository.selectList(wrapper);
        if (CollectionUtils.isNotEmpty(ens)){
            return EhsUnitBasicMapper.MAPPER.toDtoList(ens);
        }
        return null;
    }
    
    /**
     * 根据指定单元分类代码查询单元信息
     *
     * @param categoryCode 单元分类代码
     * @return List<EhsUnitDto>
     * @author QuCheng Tech
     * @since 2024/5/22
     */
    //public List<EhsUnitDto> getUnitByCategoryCode(String categoryCode){
        //LambdaQueryWrapper<EhsUnitBasic> wrapper = new LambdaQueryWrapper<>();
        //wrapper.eq(EhsUnitBasic::getCategorycode,categoryCode);
        //
        //List<EhsUnitBasic> ens = repository.selectList(wrapper);
        //if (CollectionUtils.isNotEmpty(ens)){
        //    return EhsUnitBasicMapper.MAPPER.toDtoList(ens);
        //}
        //return null;
    //}
    
}
